Comprobaciones de Propiedades Excedentes en TypeScript: Fortaleciendo la Seguridad de Tipos de Objeto

            
interface User {
  name: string;
  age: number;
}

const newUser: User = {
  name: 'Alice',
  age: 30,
  email: 'alice@example.com' // Error: El literal de objeto solo puede especificar propiedades conocidas, y 'email' no existe en el tipo 'User'.
};

            

              
                Copy
              
            
          

            
interface Product {
  id: number;
  name: string;
}

function displayProduct(product: Product): void {
  console.log(`Product ID: ${product.id}, Name: ${product.name}`);
}

displayProduct({
  id: 101,
  name: 'Laptop',
  price: 1200 // Error: El argumento de tipo '{ id: number; name: string; price: number; }' no es asignable al parámetro de tipo 'Product'.
             // El literal de objeto solo puede especificar propiedades conocidas, y 'price' no existe en el tipo 'Product'.
});

            

              
                Copy
              
            
          

            
interface Config {
  timeout: number;
}

function setupConfig(config: Config) {
  console.log(`Timeout set to: ${config.timeout}`);
}

const userProvidedConfig = {
  timeout: 5000,
  retries: 3 // Esta propiedad 'retries' es una propiedad excedente según 'Config'
};

setupConfig(userProvidedConfig); // ¡Sin error!

// Aunque userProvidedConfig tiene una propiedad extra, la comprobación se omite
// porque no es un literal de objeto que se pasa directamente.
// TypeScript comprueba el tipo de userProvidedConfig en sí mismo.
// Si userProvidedConfig se hubiera declarado con el tipo Config, un error habría ocurrido antes.
// Sin embargo, si se declara como 'any' o un tipo más amplio, el error se pospone.

// Una forma más precisa de mostrar la omisión:
let anotherConfig;

if (Math.random() > 0.5) {
  anotherConfig = {
    timeout: 1000,
    host: 'localhost' // Propiedad excedente
  };
} else {
  anotherConfig = {
    timeout: 2000,
    port: 8080 // Propiedad excedente
  };
}

setupConfig(anotherConfig as Config); // Sin error debido a la aserción de tipo y la omisión

// La clave es que 'anotherConfig' no es un literal de objeto en el punto de asignación a setupConfig.
// Si tuviéramos una variable intermedia tipada como 'Config', la asignación inicial fallaría.

// Ejemplo de variable intermedia:
let intermediateConfig: Config;

intermediateConfig = {
  timeout: 3000,
  logging: true // Error: El literal de objeto solo puede especificar propiedades conocidas, y 'logging' no existe en el tipo 'Config'.
};

            

              
                Copy
              
            
          

            
interface Settings {
  theme: 'dark' | 'light';
}

const mySettings = {
  theme: 'dark',
  fontSize: 14 // Propiedad excedente
} as Settings;

// No hay error aquí debido a la aserción de tipo.
// Le estamos diciendo a TypeScript: "Confía en mí, este objeto se ajusta a Settings."
console.log(mySettings.theme);
// console.log(mySettings.fontSize); // Esto causaría un error en tiempo de ejecución si fontSize no estuviera realmente allí.

            

              
                Copy
              
            
          

            
interface FlexibleObject {
  id: number;
  [key: string]: any; // Permite cualquier clave de tipo string con cualquier valor
}

const flexibleItem: FlexibleObject = {
  id: 1,
  name: 'Widget',
  version: '1.0.0'
};

// No hay error porque 'name' y 'version' están permitidos por la firma de índice.
console.log(flexibleItem.name);

            

              
                Copy
              
            
          

            
interface BaseConfig {
  host: string;
}

interface ExtendedConfig extends BaseConfig {
  port: number;
}

const defaultConfig: BaseConfig = {
  host: 'localhost'
};

const userConfig = {
  port: 8080,
  timeout: 5000 // Propiedad excedente en relación a BaseConfig, pero esperada por el tipo fusionado
};

// Propagando en un nuevo literal de objeto que se ajusta a ExtendedConfig
const finalConfig: ExtendedConfig = {
  ...defaultConfig,
  ...userConfig
};

// Esto generalmente está bien porque 'finalConfig' se declara como 'ExtendedConfig'
// y las propiedades coinciden. La comprobación se realiza sobre el tipo de 'finalConfig'.

// Consideremos un escenario donde *fallaría*:

interface SmallConfig {
  key: string;
}

const data1 = { key: 'abc', value: 123 }; // 'value' es extra aquí
const data2 = { key: 'xyz', status: 'active' }; // 'status' es extra aquí

// Intentar asignar a un tipo que no admite extras

// const combined: SmallConfig = {
//   ...data1, // Error: El literal de objeto solo puede especificar propiedades conocidas, y 'value' no existe en el tipo 'SmallConfig'.
//   ...data2  // Error: El literal de objeto solo puede especificar propiedades conocidas, y 'status' no existe en el tipo 'SmallConfig'.
// };

// El error ocurre porque el literal de objeto formado por la sintaxis de propagación
// contiene propiedades ('value', 'status') no presentes en 'SmallConfig'.

// Si creamos una variable intermedia con un tipo más amplio:

const temp: any = {
  ...data1,
  ...data2
};

// Luego, al asignar a SmallConfig, la comprobación de propiedad excedente se omite en la creación inicial del literal,
// pero la comprobación de tipo en la asignación aún podría ocurrir si el tipo de temp se infiere de manera más estricta.
// Sin embargo, si temp es 'any', no se realiza ninguna comprobación hasta la asignación a 'combined'.

// Aclaremos el entendimiento de la propagación con las comprobaciones de propiedades excedentes:
// La comprobación ocurre cuando el literal de objeto creado por la sintaxis de propagación se asigna
// a una variable o se pasa a una función que espera un tipo más específico.

interface SpecificShape { 
  id: number;
}

const objA = { id: 1, extra1: 'hello' };
const objB = { id: 2, extra2: 'world' };

// Esto fallará si SpecificShape no permite 'extra1' o 'extra2':
// const merged: SpecificShape = {
//   ...objA,
//   ...objB
// };

// La razón por la que falla es que la sintaxis de propagación crea efectivamente un nuevo literal de objeto.
// Si objA y objB tuvieran claves superpuestas, la última ganaría. El compilador
// ve este literal resultante y lo comprueba contra 'SpecificShape'.

// Para que funcione, podrías necesitar un paso intermedio o un tipo más permisivo:

const tempObj = {
  ...objA,
  ...objB
};

// Ahora, si tempObj tiene propiedades que no están en SpecificShape, la asignación fallará:
// const mergedCorrected: SpecificShape = tempObj; // Error: El literal de objeto solo puede especificar propiedades conocidas...

// La clave es que el compilador analiza la forma del literal de objeto que se está formando.
// Si ese literal contiene propiedades no definidas en el tipo de destino, es un error.

// El caso de uso típico para la sintaxis de propagación con comprobaciones de propiedades excedentes:

interface UserProfile {
  userId: string;
  username: string;
}

interface AdminProfile extends UserProfile {
  adminLevel: number;
}

const baseUserData: UserProfile = {
  userId: 'user-123',
  username: 'coder'
};

const adminData = {
  adminLevel: 5,
  lastLogin: '2023-10-27'
};

// Aquí es donde la comprobación de propiedad excedente es relevante:
// const adminProfile: AdminProfile = {
//   ...baseUserData,
//   ...adminData // Error: El literal de objeto solo puede especificar propiedades conocidas, y 'lastLogin' no existe en el tipo 'AdminProfile'.
// };

// El literal de objeto creado por la propagación tiene 'lastLogin', que no está en 'AdminProfile'.
// Para solucionarlo, 'adminData' debería idealmente conformarse a AdminProfile o la propiedad excedente debería manejarse.

// Enfoque corregido:
const validAdminData = {
  adminLevel: 5
};

const adminProfileCorrect: AdminProfile = {
  ...baseUserData,
  ...validAdminData
};

console.log(adminProfileCorrect.userId);
console.log(adminProfileCorrect.adminLevel);

            

              
                Copy
              
            
          

            
interface UserProfile {
  id: number;
  name: string;
}

interface UserWithMetadata extends UserProfile {
  metadata: {
    [key: string]: any;
  };
}

// O más comúnmente con un alias de tipo y sintaxis rest:
type UserProfileWithMetadata = UserProfile & {
  [key: string]: any;
};

const user1: UserProfileWithMetadata = {
  id: 1,
  name: 'Bob',
  email: 'bob@example.com',
  isAdmin: true
};

// Sin error, ya que 'email' e 'isAdmin' son capturados por la firma de índice en UserProfileWithMetadata.
console.log(user1.email);
console.log(user1.isAdmin);

// Otra forma usando parámetros rest en una definición de tipo:
interface ConfigWithRest {
  apiUrl: string;
  timeout?: number;
  // Captura todas las demás propiedades en 'extraConfig'
  [key: string]: any;
}

const appConfig: ConfigWithRest = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
  featureFlags: {
    newUI: true,
    betaFeatures: false
  }
};

console.log(appConfig.featureFlags);

            

              
                Copy
              
            
          

            
interface Employee {
  employeeId: string;
  department: string;
}

function processEmployeeData(data: Employee & { [key: string]: any }) {
  const { employeeId, department, ...otherDetails } = data;

  console.log(`Employee ID: ${employeeId}`);
  console.log(`Department: ${department}`);
  console.log('Other details:', otherDetails);
  // otherDetails contendrá cualquier propiedad no desestructurada explícitamente,
  // como 'salary', 'startDate', etc.
}

const employeeInfo = {
  employeeId: 'emp-789',
  department: 'Engineering',
  salary: 90000,
  startDate: '2022-01-15'
};

processEmployeeData(employeeInfo);

// Incluso si employeeInfo tuviera una propiedad extra inicialmente, la comprobación de propiedad excedente
// se omite si la firma de la función la acepta (p. ej., usando una firma de índice).
// Si processEmployeeData estuviera tipada estrictamente como 'Employee', y employeeInfo tuviera 'salary',
// ocurriría un error SI employeeInfo fuera un literal de objeto pasado directamente.
// Pero aquí, employeeInfo es una variable, y el tipo de la función maneja los extras.

            

              
                Copy
              
            
          

            
interface UserProfile {
  id: number;
  name: string;
  email?: string; // email opcional
}

const userWithEmail: UserProfile = {
  id: 2,
  name: 'Charlie',
  email: 'charlie@example.com'
};

const userWithoutEmail: UserProfile = {
  id: 3,
  name: 'David'
};

// Si intentamos agregar una propiedad que no está en UserProfile:
// const userWithExtra: UserProfile = {
//   id: 4,
//   name: 'Eve',
//   phoneNumber: '555-1234'
// }; // Error: El literal de objeto solo puede especificar propiedades conocidas, y 'phoneNumber' no existe en el tipo 'UserProfile'.

            

              
                Copy
              
            
          

            
interface ProductConfig {
  id: string;
  version: string;
}

// Imagina que esto proviene de una fuente externa o un módulo menos estricto
const externalConfig = {
  id: 'prod-abc',
  version: '1.2',
  debugMode: true // Propiedad excedente
};

// Si sabes que 'externalConfig' siempre tendrá 'id' y 'version' y quieres tratarlo como ProductConfig:
const productConfig = externalConfig as ProductConfig;

// Esta aserción omite la comprobación de propiedad excedente en `externalConfig` en sí.
// Sin embargo, si pasaras un literal de objeto directamente:

// const productConfigLiteral: ProductConfig = {
//   id: 'prod-xyz',
//   version: '2.0',
//   debugMode: false
// }; // Error: El literal de objeto solo puede especificar propiedades conocidas, y 'debugMode' no existe en el tipo 'ProductConfig'.

            

              
                Copy
              
            
          

            
interface Shape {
  kind: 'circle' | 'square';
}

interface Circle extends Shape {
  kind: 'circle';
  radius: number;
}

interface Square extends Shape {
  kind: 'square';
  sideLength: number;
}

function calculateArea(shape: Shape) {
  if (shape.kind === 'circle') {
    // TypeScript sabe que 'shape' es un Circle aquí
    console.log(Math.PI * shape.radius ** 2);
  } else if (shape.kind === 'square') {
    // TypeScript sabe que 'shape' es un Square aquí
    console.log(shape.sideLength ** 2);
  }
}

const circleData = {
  kind: 'circle' as const, // Usando 'as const' para la inferencia de tipo literal
  radius: 10,
  color: 'red' // Propiedad excedente
};

// Cuando se pasa a calculateArea, la firma de la función espera 'Shape'.
// La función en sí accederá correctamente a 'kind'.
// Si calculateArea esperara 'Circle' directamente y recibiera circleData
// como un literal de objeto, 'color' sería un problema.

// Ilustremos la comprobación de propiedad excedente con una función que espera un subtipo específico:

function processCircle(circle: Circle) {
  console.log(`Processing circle with radius: ${circle.radius}`);
}

// processCircle(circleData); // Error: El argumento de tipo '{ kind: "circle"; radius: number; color: string; }' no es asignable al parámetro de tipo 'Circle'.
                         // El literal de objeto solo puede especificar propiedades conocidas, y 'color' no existe en el tipo 'Circle'.

// Para solucionar esto, puedes desestructurar o usar un tipo más permisivo para circleData:

const { color, ...circleDataWithoutColor } = circleData;
processCircle(circleDataWithoutColor);

// O definir circleData para incluir un tipo más amplio:

const circleDataWithExtras: Circle & { [key: string]: any } = {
  kind: 'circle',
  radius: 15,
  color: 'blue'
};
processCircle(circleDataWithExtras); // Ahora funciona.

            

              
                Copy